VMWare: Tool Support for Automatic Verification of Structural and Semantic Correctness in Product Line Models

International audienceThe verification of variability models is recognized as one of the key challenges for automated development of product lines. Some computational tools have been proposed to verify product line models and product line configurations models. VMWare is a tool integrating different criteria to verify structural and semantic correctness of models derived from the FORE metamodel. Our tool gives the possibility of (i) build feature-based product line models and product line configuration models, (ii) verify their structural and semantic correctness in a completely automated manner and (iii) import/export them in XMI files

Combining configuration and recommendation to enable an interactive guidance of product line configuration

This paper is interested in e-commerce for complex configurable products/systems. E-commerce makes a wide use of recommendation techniques to help customers identify relevant products or services in large collections of offers. One particular way to achieve this is to offer customers a panel of options among which they can select their preferred ones. A trend in the industry is to go a step further, beyond the selection of pre-defined products from a catalogue by handling products customization. The systems engineering community has shown that, based on product line engineering methods, techniques and tools, it is possible to produce customized products efficiently and at low cost. The problem is that there are usually so many products in a PL that it is impossible to specify all of them explicitly, and therefore traditional recommendation techniques cannot be simply applied. This paper proposes an approach that combines two complementary forms of guidance: configuration and recommendation, to help customers define their own products out of a product line specification. The proposed approach, called interactive configuration supports the combination by organizing the configuration process in a series of partial configurations where decisions are made by the recommendation. This paper illustrates this process by applying it to an example with the content based method for recommendation and the a priori configuration approach

Criteria for the verification of feature models

Product Line (PL) based development is a promising approach to develop software intensive systems. Experience already report multiple benefits, such as reduced time to market, better reuse, and reduced development costs. PL modelling languages, in particular to create feature models (FMs), and PL configuration processes are now supported by market tools. Although there is a wealth of research works on the theme of FM verification, there is to our knowledge no comprehensive method, technique or tool. However, it is crucial that when verifying a FM, the right criteria are considered: any error in a FM will inevitably spread to the configured software and generate PL architecture stability issues, with a serious risk of undermining the expected benefits. Dealing with key issues such as selecting the 'right' set of verification criteria or defining a small core of criteria from which all other could be derived calls for a consistent definition of all the criteria. This paper presents an original literature survey of FM verification criteria in which all the criteria are (i) classified according to their purpose and (ii) formalized consistently using first order logic

Combining configuration and recommendation to define an interactive product line configuration approach

This paper is interested in e-commerce for complex configurable products/systems. In e-commerce, satisfying the customer needs is a vital concern. One particular way to achieve this is to offer customers a panel of options among which they can select their preferred ones. While solution exists, they are not adapted for highly complex configurable systems such as product lines. This paper proposes an approach that combines two complementary forms of guidance: configuration and recommendation, to help customers define their own products out of a product line specification. The proposed approach, called interactive configuration supports the combination by organizing the configuration process in a series of partial configurations where decisions are made by the recommendation.Comment: arXiv admin note: text overlap with arXiv:1108.5586 by other author

The Baxter Return of Experience on the Use of Association Rules to Construct its Product Line Model

A very promising approach to increase productivity, quality and competitiveness approach of information systems development is the reuse and development of a family of systems guided by Product Line (PL) practices. One of the main goals of PL engineering is to develop a model that represents the family of products (product line model PLM), which is then customized to configure individual products. The successful definition of PLMs that accurately represents the information in the requirement specifications still depends heavily on the intuition and experience of the software architect. Our work provides assistance for this process. We have developed a semi-automated method to construct product line models based on collection of related artifacts or existent products models as a result of a feature mining process. The approach is evaluated using bill of material as a collection of product models to develop and construct a constraint based PLM. The performance of our method is calculated by estimating the time complexity and constructing the PLM for different random samples of 536 products in Baxter Bioscience. More than 92% of the relationships are properly predicted only by using 75% of the total available products

A Method based on Association Rules to Construct Product Line Model

International audienceThe success of a product line is the ability to improve application engineering, heavily depends on the quality of Product Line Models (PLMs). This paper reports on our effort to develop a method that exploits mining techniques such as the apriori algorithm, independence tests and the like to automate the construction of a PLM specified with FORE, starting from a collection of Product Models (PMs). Using these techniques, the proposed method guides the identification of candidate features, group cardinalities and dependencies. These can be used to progressively construct the PLM consistently with the existing PMs. The method was developed and tested in an industry setting starting with bills of materials as a collection of PMs. One interesting lesson learn from this experiment is that while the PLM is constructed, the domain engineer discovers errors in PMs. We believe that this advocates for a tighter intertwining between domain engineering and application engineering

Solving Integer Constraint in Reuse Based Requirements Engineering

International audienceProduct Lines (PL) have proved an effective approach to reuse-based systems development. Several modelling languages were proposed so far to specify PL. Although they can be very different, these languages show two common features: they emphasize (a) variability, and (b) the specification of constraints to define acceptable configurations. It is now widely acknowledged that configuring a product can be considered as a constraint satisfaction problem. It is thus natural to consider constraint programming as a first choice candidate to specify constraints on PL. For instance, the different constraints that can be specified using the FODA language can easily be expressed using boolean constraints, which enables automated calculation and configuration using a SAT solver. But constraint programming proposes other domains than the boolean domain: for instance integers, real, or sets. The integer domain was, for instance, proposed by Benavides to specify constraints on feature attributes. This paper proposes to further explore the use of integer constraint programming to specify PL constraints. The approach was implemented in a prototype tool. Its use in a real case showed that constraint programming encompasses different PL modeling languages (such as FORE, OVM, or else), and allows to specify complex constraints that are difficult to specify with these languages

Using Integer Constraint Solving in Reuse Based Requirements Engineering

Product Lines (PL) have proved an effective approach to reuse-based systems development. Several modeling languages were proposed so far to specify PL. Although they can be very different, these languages show two common features: they emphasize (a) variability, and (b) the specification of constraints to define acceptable configurations. It is now widely acknowledged that configuring a product can be considered as a constraint satisfaction problem. It is thus natural to consider constraint programming as a first choice candidate to specify constraints on PL. For instance, the different constraints that can be specified using the FODA language can easily be expressed using boolean constraints, which enables automated calculation and configuration using a SAT solver. But constraint programming proposes other domains than the boolean domain: for instance integers, real, or sets. The integer domain was, for instance, proposed by Benavides to specify constraints on feature attributes. This paper proposes to further explore the use of integer constraint programming to specify PL constraints. The approach was implemented in a prototype tool. Its use in a real case showed that constraint programming encompasses different PL modeling languages (such as FORE, OVM, or else), and allows specifying complex constraints that are difficult to specify with these languages

Runtime Requirements Monitoring Framework for Adaptive e-Learning Systems

International audienceAs academic learners and companies are turning to e-learning courses to achieve their personal and professional goals, it becomes more and more important to handle service quality in this sector. Despite scientific research conducted to personalize the learning process and meet learner's requirements under adaptive e-learning systems, however, the specification and management of quality attribute is particularly challenging due to problems arising from environmental variability. In our view, a detailed and high-level specification of requirements supported through the whole system lifecycle is needed for a comprehensive management of adaptive e-learning systems, especially in continuously changing environmental conditions. In this paper, we propose a runtime requirements monitoring to check the conformity of adaptive e-learning systems to their requirements and ensure that the activities offered by these learning environments can achieve the desired learning outcomes. As a result, when deviations (i.e., not satisfied requirements) occur, they are identified and then notified during system operation. With our approach, the requirements are supported during the whole system lifecycle. First, we specify system's requirements in the form of a dynamic software product line. This specification applies a novel requirements engineering language that combines goal-driven requirements with features and claims and avoid the enumeration of all desired adaptation strategies (i.e. when an adaptation should be applied) at the design time. Second, the specification is automatically transformed into a constraint satisfaction problem that reduces the requirements monitoring into a constraint program at runtime

Constraint Programming as a Means to Manage Configurations in Self-Adaptive Systems

International audienceIn recent years, new software architectures have been developed in which components can be bound and unbound dynamically as the context demands. This capacity to dynamically adapt the software's structure, behaviour and quality of service should make resilience easier to achieve by allowing systems to respond more flexibly to changing environmental contexts. However, because the decision of how to react to a new context is devolved to a run-time decision-making element that senses the context and selects an appropriate component configuration, a new approach to how software is specified is needed. A self-adaptive system that uses architectural adaptation may be conceptualized as a dynamic SPL. In this paper we argue that the problem of specifying a DSPL can be reduced to a constraint satisfaction problem. We combine goal modeling techniques with constraint programming to provide the analyst with a means to identify the system variants best suited to the various environmental contexts that a system might encounter at runtime. We illustrate our approach using the example of a self-adaptive wireless sensor network